﻿// 3712. 根能抵达的点.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory.h>

using namespace std;
/*
https://www.acwing.com/problem/content/3715/


给定一棵由 N个节点构成的带边权树。
节点编号从 0到 N−1，其中 0号点为根节点。
最初，从根节点可以抵达所有节点（包括自己）。

如果我们将所有边权小于 X的边全部删掉，那么从根节点可以抵达的节点数目就可能发生改变。
现在，给定一个整数 Y，请你找到最小的非负整数 X，使得所有边权小于 X
的边都被删掉以后，根节点能够抵达的节点数目（包括自己）不超过 Y。

输入格式
第一行包含整数 T，表示共有 T组测试数据。
每组数据第一行包含两个整数 N,Y。
接下来 N−1行，每行包含三个整数 U,V,W
，表示点 U和点 V之间存在一条权值为 W的边。
输出格式
每组数据输出一行，一个 X。

注意，X应不小于 0。

数据范围
1≤T≤100,
1≤N≤20000,
1≤Y≤N,
0≤U,V<N,
0≤W≤107,
保证在一个测试点中，所有 N的和不超过 105。

输入样例：
2
3 2
0 1 2
0 2 3
6 3
0 1 8
0 2 3
1 3 2
1 4 5
2 5 6
输出样例：
3
4




2
6 3
0 1 8
2 0 3
1 3 2
1 4 5
2 5 6
3 2
0 1 2
0 2 3


3
4
*/
const int N = 40010;
int h[N/2], e[N], ne[N], w[N], idx;
int t, n, y;
int vis[N];
int res;

void add(int a, int b, int v) {
	e[idx] = b, ne[idx] = h[a], w[idx] = v, h[a] = idx++;
}

void dfs(int p, int x) {
	res++;
	//if (res > y) return;
	vis[p] = 1;
	for (int i = h[p]; i != -1; i = ne[i]) {
		int j = e[i];
		if (w[i] < x || vis[j] == 1) {
			continue;
		}
		dfs(j, x);
		//if (res > y) return;
	}

	return;
}



int check(int x) {
	res = 1;
	memset(vis, 0, sizeof vis);
	vis[0] = 1;
	for (int i = h[0]; i != -1; i = ne[i]) {
		int j = e[i];
		if (w[i] < x || vis[j] == 1) {
			continue;
		}
		dfs(j, x);
	}

	return res;
}

void solve() {
	memset(h, -1, sizeof h);
	idx = 0;

	//cin >> n >> y;
	scanf("%d%d", &n, &y);

	for (int i = 1; i < n; i++) {
		int a, b, v;
		//cin >> a >> b >> v;
		scanf("%d%d%d", &a, &b, &v);
		add(a, b, v);
		add(b, a, v);
	}

	int l = 0; int r = 1e7 + 10;
	while (l < r) {
		int mid = (l + r) >> 1;
		if (check(mid) <= y) {
			r = mid;
		}
		else {
			l = mid + 1;
		}
	}

	cout << l << endl;

}

int main()
{
	//cin >> t;
	scanf("%d", &t);
	while (t--) {
		solve();
	}
	return 0;
}
